package com.jrabbits.impl.sys.service;
import java.util.Collection;
import java.util.Date;
import java.util.List;

import org.apache.shiro.session.Session;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.jrabbits.api.sys.entity.Office;
import com.jrabbits.api.sys.entity.Role;
import com.jrabbits.api.sys.entity.User;
import com.jrabbits.api.sys.service.SystemService;
import com.jrabbits.common.constant.CacheDict;
import com.jrabbits.common.filter.DataScopeFilter;
import com.jrabbits.common.persistence.Page;
import com.jrabbits.common.security.shiro.session.SessionDAO;
import com.jrabbits.common.service.ServiceException;
import com.jrabbits.common.utils.CacheUtils;
import com.jrabbits.common.utils.GeneralPassWord;
import com.jrabbits.common.utils.StringUtils;
import com.jrabbits.impl.sys.dao.MenuDao;
import com.jrabbits.impl.sys.dao.RoleDao;
import com.jrabbits.impl.sys.dao.UserDao;

/**
 * 系统管理，安全相关实体的管理类,包括用户、角色、菜单.
 * @author jrabbits
 * @version 2013-12-05
 */

@Transactional(readOnly = true)
@Service("SystemService")
public class SystemServiceImpl  implements SystemService{
	
	
	@Autowired
	private UserDao userDao;
	@Autowired
	private RoleDao roleDao;
	@Autowired
	private MenuDao menuDao;
	@Autowired
	private SessionDAO sessionDao;
	
	public SessionDAO getSessionDao() {
		return sessionDao;
	}
	
	/**
	 * 获取用户
	 * @param id
	 * @return
	 */
//	public User getUser(String id) {
//		return UserUtils.get(id);
//	}

	/**
	 * 根据登录名获取用户
	 * @param loginName
	 * @return
	 */
//	public User getUserByLoginName(String loginName) {
//		return UserUtils.getByLoginName(loginName);
//	}
	
	public Page<User> findUser(Page<User> page, User user) {
		
		// 生成数据权限过滤条件（dsf为dataScopeFilter的简写，在xml中使用 ${sqlMap.dsf}调用权限SQL）
		user.getSqlMap().put("dsf", DataScopeFilter.dataScopeFilter(user.getCurrentUser(), "o", "a"));
				
		// 设置分页参数
		user.setPage(page);
		// 执行分页查询
		page.setList(userDao.findList(user));
		return page;
	}
	
	/**
	 * 无分页查询人员列表
	 * @param user
	 * @return
	 */
	public List<User> findUser(User user){
		// 生成数据权限过滤条件（dsf为dataScopeFilter的简写，在xml中使用 ${sqlMap.dsf}调用权限SQL）
		user.getSqlMap().put("dsf", DataScopeFilter.dataScopeFilter(user.getCurrentUser(), "o", "a"));
		List<User> list = userDao.findList(user);
		return list;
	}

	/**
	 * 通过部门ID获取用户列表，仅返回用户id和name（树查询用户时用）
	 * @param user
	 * @return
	 */
	public List<User> findUserByOfficeId(String officeId) {
		
		User user = new User();
		user.setOffice(new Office(officeId));
		return userDao.findUserByOfficeId(user);
	}
	
	@Transactional(readOnly = false)
	public void saveUser(User user) {
		if (user.getIsNewRecord()){
			//user.preInsert();
			userDao.insert(user);
		}else{
			// 清除原用户机构用户缓存
			User oldUser = userDao.get(user.getId());
//			if (oldUser.getOffice() != null && oldUser.getOffice().getId() != null){
//				CacheUtils.remove(CacheDict.USER_CACHE, CacheDict.USER_CACHE_LIST_BY_OFFICE_ID_ + oldUser.getOffice().getId());
//			}
			// 更新用户数据
			//user.preUpdate();
			userDao.update(user);
		}
		if (StringUtils.isNotBlank(user.getId())){
			// 更新用户与角色关联
			userDao.deleteUserRole(user);
			if (user.getRoleList() != null && user.getRoleList().size() > 0){
				userDao.insertUserRole(user);
			}else{
				throw new ServiceException(user.getLoginName() + "没有设置角色！");
			}
			// 将当前用户同步到Activiti
			//saveActivitiUser(user);
			// 清除用户缓存
		//	UserUtils.clearCache(user);
//			// 清除权限缓存
//			systemRealm.clearAllCachedAuthorizationInfo();
		}
	}
	
	@Transactional(readOnly = false)
	public void updateUserInfo(User user) {
		//user.preUpdate();
		userDao.updateUserInfo(user);
		// 清除用户缓存
		//UserUtils.clearCache(user);
//		// 清除权限缓存
//		systemRealm.clearAllCachedAuthorizationInfo();
	}
	
	@Transactional(readOnly = false)
	public void deleteUser(User user) {
		userDao.delete(user);
		// 同步到Activiti
	//	deleteActivitiUser(user);
		// 清除用户缓存
	//	UserUtils.clearCache(user);
//		// 清除权限缓存
//		systemRealm.clearAllCachedAuthorizationInfo();
	}
	
	@Transactional(readOnly = false)
	public void updatePasswordById(String id, String loginName, String newPassword) {
		User user = new User(id);
		user.setPassword(GeneralPassWord.entryptPassword(newPassword));
		userDao.updatePasswordById(user);
		// 清除用户缓存
		user.setLoginName(loginName);
//		// 清除权限缓存
//		systemRealm.clearAllCachedAuthorizationInfo();
	}
	
	@Transactional(readOnly = false)
	public void updateUserLoginInfo(User user) {
		// 保存上次登录信息
		user.setOldLoginIp(user.getLoginIp());
		user.setOldLoginDate(user.getLoginDate());
		// 更新本次登录信息
		//user.setLoginIp(StringUtils.getRemoteAddr(request));
		user.setLoginDate(new Date());
		userDao.updateLoginInfo(user);
	}
	
	
	/**
	 * 获得活动会话
	 * @return
	 */
	public Collection<Session> getActiveSessions(){
		return sessionDao.getActiveSessions(false);
	}
	
	//-- Role Service --//
	
	public Role getRole(String id) {
		return roleDao.get(id);
	}

	public Role getRoleByName(String name) {
		Role r = new Role();
		r.setName(name);
		return roleDao.getByName(r);
	}
	
	public Role getRoleByEnname(String enname) {
		Role r = new Role();
		r.setEnname(enname);
		return roleDao.getByEnname(r);
	}
	
	public List<Role> findRole(Role role){
		return roleDao.findList(role);
	}
	
//	public List<Role> findAllRole(){
//		return UserUtils.getRoleList();
//	}
	
	@Transactional(readOnly = false)
	public void saveRole(Role role) {
		if (StringUtils.isBlank(role.getId())){
			//role.preInsert();
			roleDao.insert(role);
			// 同步到Activiti
			//saveActivitiGroup(role);
		}else{
			//role.preUpdate();
			roleDao.update(role);
		}
		// 更新角色与菜单关联
		roleDao.deleteRoleMenu(role);
		if (role.getMenuList().size() > 0){
			roleDao.insertRoleMenu(role);
		}
		// 更新角色与部门关联
		roleDao.deleteRoleOffice(role);
		if (role.getOfficeList().size() > 0){
			roleDao.insertRoleOffice(role);
		}
		// 同步到Activiti
		//saveActivitiGroup(role);
		// 清除用户角色缓存
	//	UserUtils.removeCache(CacheDict.CACHE_ROLE_LIST);
//		// 清除权限缓存
//		systemRealm.clearAllCachedAuthorizationInfo();
	}

	@Transactional(readOnly = false)
	public void deleteRole(Role role) {
		roleDao.delete(role);
		// 同步到Activiti
		//deleteActivitiGroup(role);
		// 清除用户角色缓存
		//UserUtils.removeCache(CacheDict.CACHE_ROLE_LIST);
//		// 清除权限缓存
//		systemRealm.clearAllCachedAuthorizationInfo();
	}
	
	@Transactional(readOnly = false)
	public Boolean outUserInRole(Role role, User user) {
		List<Role> roles = user.getRoleList();
		for (Role e : roles){
			if (e.getId().equals(role.getId())){
				roles.remove(e);
				saveUser(user);
				return true;
			}
		}
		return false;
	}
	
	@Transactional(readOnly = false)
	public User assignUserToRole(Role role, User user) {
		if (user == null){
			return null;
		}
		List<String> roleIds = user.getRoleIdList();
		if (roleIds.contains(role.getId())) {
			return null;
		}
		user.getRoleList().add(role);
		saveUser(user);
		return user;
	}

	//-- Menu Service --//
	
	

	@Override
	public Collection<Session> getActiveSessions(boolean includeLeave) {
		return sessionDao.getActiveSessions(includeLeave);
	}

	@Override
	public Collection<Session> getActiveSessions(boolean includeLeave,
			Object principal, Session filterSession) {
		
		return sessionDao.getActiveSessions(includeLeave, principal, filterSession);
	}
	@Override
	public void deleteSession(Session session) {
		sessionDao.delete(session);
	}
	
}
